let app = getApp();

Page({
  /**
   * 页面的初始数据
   */
  data: {
    url: '',
    pageNum: 1,
    pageSize: 10,
    pages: 0,
    total: 0,
    question: [],
    index: 0,
    users: '',
    id: 0,
    swiperHeight: 0,
    psych: [],
    loading: false,
    refreshing: false,
    hasMore: true,
    sortType: 'newest', // newest: 最新发表, latest: 最后回复, count: 回复数量
    replyCounts: {} // 存储每个问题的回复数量
  },

  /**
   * 获取心理咨询师数据
   */
  getPsych() {
    wx.showLoading({
      title: '加载中...'
    })
    
    wx.request({
      url: this.data.url + 'psych/alls',
      method: 'GET',
      success: (resp) => {
        console.log('获取心理数据响应：', resp.data);
        if (resp.data && resp.data.code === 200 && resp.data.data) {
          this.setData({
            psych: resp.data.data
          })
        } else {
          console.warn('脑数据格式异常：', resp.data);
          this.setData({
            psych: []
          })
        }
      },
      fail: (err) => {
        console.error('获取心理数据失败：', err);
        this.setData({
          psych: []
        })
        wx.showToast({
          title: '网络错误',
          icon: 'none'
        })
      },
      complete: () => {
        wx.hideLoading()
      }
    })
  },

  /**
   * 获取回复数量数据
   */
  getReplyCounts() {
    return new Promise((resolve) => {
      const apiUrl = this.data.url.endsWith('/') ? 
        this.data.url + 'psyreply' : 
        this.data.url + '/psyreply';
      
      console.log('获取回复数量数据，API URL:', apiUrl);
      
      wx.request({
        url: apiUrl,
        method: 'GET',
        success: (resp) => {
          console.log('获取回复数量响应：', resp.data);
          
          if (resp.data && (resp.data.code === 200 || resp.data.code === 0) && resp.data.data) {
            const replyData = resp.data.data.list || [];
            console.log('原始回复数据:', replyData);
            
            // 统计每个问题的回复数量
            const replyCounts = {};
            replyData.forEach(item => {
              const questionId = parseInt(item.qaId) || parseInt(item.questionId);
              if (questionId) {
                replyCounts[questionId] = (replyCounts[questionId] || 0) + 1;
              }
            });
            
            console.log('统计的回复数量:', replyCounts);
            
            this.setData({
              replyCounts: replyCounts
            }, () => {
              console.log('回复数量数据设置完成');
              resolve();
            });
          } else {
            console.warn('回复数量数据异常：', resp.data);
            this.setData({
              replyCounts: {}
            }, () => {
              resolve();
            });
          }
        },
        fail: (err) => {
          console.error('获取回复数量失败：', err);
          this.setData({
            replyCounts: {}
          }, () => {
            resolve();
          });
        }
      });
    });
  },

  /**
   * 获取问题列表数据（分页）
   */
  getQuestion(callback) {
    if (this.data.loading) return;
    
    this.setData({ loading: true })
    
    if (!this.data.refreshing) {
      wx.showLoading({
        title: '加载中...'
      })
    }
    
    const params = {
      pageNum: this.data.pageNum,
      pageSize: this.data.pageSize,
      sortType: this.data.sortType
    }
    
    console.log('发送请求参数：', params)
    
    wx.request({
      url: this.data.url + 'psyreply/sanbiao',
      method: 'GET',
      data: params,
      success: (resp) => {
        console.log('获取问题列表响应：', resp.data);
        console.log('完整响应结构:', JSON.stringify(resp.data, null, 2));
        
        if (resp.data && resp.data.code === 200 && resp.data.data) {
          const newList = resp.data.data.list || []
          const newPages = resp.data.data.pages || 0
          const total = resp.data.data.total || 0
          
          console.log('分页信息：', {
            total: total,
            pages: newPages,
            currentPage: this.data.pageNum,
            pageSize: this.data.pageSize,
            currentListLength: newList.length
          })
          
          // 先获取回复数量，再处理问题列表
          this.getReplyCounts().then(() => {
            console.log('回复数量获取完成，当前replyCounts:', this.data.replyCounts);
            
            // 数据处理：确保每条数据都有必要的字段
            const processedList = newList.map((item, index) => {
              console.log(`处理第${index}条数据:`, {
                psych: item.psych,
                replyCount: item.psych?.replyCount,
                id: item.psych?.id
              });
              
              // 使用从replyCounts中获取的实际回复数量
              const actualReplyCount = this.data.replyCounts[item.psych?.id] || 0;
              console.log(`问题ID ${item.psych?.id} 的实际回复数量:`, actualReplyCount);
              
              return {
                ...item,
                psych: {
                  ...item.psych,
                  replyCount: actualReplyCount
                },
                users: item.users || [],
                hasValidData: !!(item.psych && item.users && item.users.length > 0)
              }
            })
            
            // 过滤掉无效数据
            const validList = processedList.filter(item => item.hasValidData)
            
            let updatedQuestion
            if (this.data.pageNum === 1) {
              updatedQuestion = validList
            } else {
              updatedQuestion = [...this.data.question, ...validList]
            }
            
            const hasMore = this.data.pageNum < newPages
            
            this.setData({
              question: updatedQuestion,
              pages: newPages,
              total: total,
              hasMore: hasMore,
              loading: false
            }, () => {
              console.log('数据更新成功，当前问题数量：', updatedQuestion.length)
              console.log('预期总数：', total, '实际显示：', updatedQuestion.length)
              console.log('是否还有更多数据：', hasMore)
              console.log('第一条数据的回复数量:', updatedQuestion[0]?.psych?.replyCount)
              if (callback) callback()
            })
          }).catch(err => {
            console.error('获取回复数量失败:', err);
            // 即使获取回复数量失败，也要继续处理问题列表
            const processedList = newList.map((item, index) => {
              return {
                ...item,
                psych: {
                  ...item.psych,
                  replyCount: item.psych?.replyCount || 0
                },
                users: item.users || [],
                hasValidData: !!(item.psych && item.users && item.users.length > 0)
              }
            })
            
            const validList = processedList.filter(item => item.hasValidData)
            let updatedQuestion = this.data.pageNum === 1 ? validList : [...this.data.question, ...validList]
            const hasMore = this.data.pageNum < newPages
            
            this.setData({
              question: updatedQuestion,
              pages: newPages,
              total: total,
              hasMore: hasMore,
              loading: false
            }, () => {
              if (callback) callback()
            })
          })
        } else {
          console.error('数据结构异常：', resp.data)
          this.setData({ loading: false })
          wx.showToast({
            title: '数据加载失败',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('请求失败：', err)
        this.setData({ loading: false })
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        })
      },
      complete: () => {
        if (!this.data.refreshing) {
          wx.hideLoading()
        }
      }
    })
  },

  /**
   * 跳转到问题详情页
   */
  gotoQuesDetail(e) {
    const id = e.currentTarget.dataset.id
    if (id) {
      wx.navigateTo({
        url: `/pages/index/indexAnswer/AnsQues/AnsQues?id=${id}`,
      })
    }
  },



  /**
   * 切换标签页
   */
  changeIndex(e) {
    const index = e.currentTarget.dataset.index
    const sortTypes = ['newest', 'latest', 'count']
    
    this.setData({
      index: index,
      sortType: sortTypes[index],
      pageNum: 1,
      question: []
    }, () => {
      this.getQuestion()
    })
  },

  /**
   * 重置分页数据
   */
  resetPagination() {
    this.setData({
      pageNum: 1,
      question: [],
      hasMore: true,
      pages: 0,
      total: 0
    })
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.setData({
      url: app.globalData.url,
      id: options.id || 0
    })
    
    console.log('页面加载，开始获取问题数据...')
    
    // 获取问题数据（getQuestion内部会调用getReplyCounts）
    Promise.all([
      this.getQuestion(),
      this.getPsych()
    ]).then(() => {
      console.log('所有数据加载完成')
    }).catch(err => {
      console.error('数据加载失败:', err)
    })
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {
    const query = wx.createSelectorQuery().in(this);
    query.select('#swiperContent').boundingClientRect((rect) => {
      if (rect) {
        this.setData({
          swiperHeight: rect.height
        });
      }
    }).exec();
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    // 每次页面显示时刷新数据，确保显示最新数据
    console.log('页面显示，刷新数据...')
    this.resetPagination()
    
    // 获取问题数据（getQuestion内部会调用getReplyCounts）
    Promise.all([
      this.getQuestion(),
      this.getPsych()
    ]).then(() => {
      console.log('所有数据刷新完成')
    }).catch(err => {
      console.error('数据刷新失败:', err)
    })
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {
    // 清理数据
    this.setData({
      loading: false,
      refreshing: false
    })
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {
    // 清理数据
    this.setData({
      loading: false,
      refreshing: false
    })
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    console.log('下拉刷新触发');
    this.setData({ refreshing: true })
    
    this.resetPagination()
    
    // 获取问题数据（getQuestion内部会调用getReplyCounts）
    this.getQuestion().then(() => {
      wx.stopPullDownRefresh()
      this.setData({ refreshing: false })
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1000
      })
    }).catch(err => {
      console.error('刷新失败:', err)
      wx.stopPullDownRefresh()
      this.setData({ refreshing: false })
      wx.showToast({
        title: '刷新失败',
        icon: 'none'
      })
    })
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    console.log('上拉加载更多触发，当前分页状态：', {
      currentPage: this.data.pageNum,
      totalPages: this.data.pages,
      currentDataCount: this.data.question.length,
      hasMore: this.data.hasMore
    })
    
    if (!this.data.hasMore || this.data.loading) {
      console.log('没有更多数据或正在加载中')
      return
    }
    
    const nextPage = this.data.pageNum + 1
    console.log('准备加载第', nextPage, '页数据')
    
    this.setData({
      pageNum: nextPage
    }, () => {
      console.log('页码已更新为：', this.data.pageNum)
      this.getQuestion()
    })
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '心理问答',
      path: '/pages/index/indexAnswer/indexAnswer'
    }
  }
})
